home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 March / EnigmA AMIGA RUN 05 (1996)(G.R. Edizioni)(IT)[!][issue 1996-03][Skylink CD IV].iso / earcd / util1 / rdbmnt12.lha / RDBMount_1_2 / RDBMount.c < prev    next >
C/C++ Source or Header  |  1995-10-21  |  9KB  |  313 lines
  1. /*
  2.  *    $VER:RDBMount.c - (21.10.95) Copyright © 1991 by S.R. 13:59:49 14:43:45
  3.  *
  4.  *      Created: 28 Mar 1993
  5.  *      Modified:    21 Oct 1995    14:43:45
  6.  *
  7.  * Make>> SC <file>.c
  8.  * Make>> SLink Lib:Entry.o <file>.o LIB Lib:String.lib Lib:sc.lib MAP <file>.map F,H,L,O,S,X NOICON VERBOSE SmallCode SmallData BATCH
  9.  * Ma ke>> SLink Lib:Entry.o <file>.o LIB Lib:Startup.lib Lib:String.lib MAP <file>.map F,H,L,O,S,X NOICON VERBOSE SmallCode SmallData BATCH
  10.  *
  11.  *    95.10.12:
  12.  *        Add DosType keyword.
  13.  */
  14.  
  15. #include <Main.h>
  16. #include <StringLib.h>
  17.  
  18. #include <Libraries/HardBlocks.h>
  19. /*#include <pragmas/HardBlocks_pragmas.h> */
  20.  
  21. #define MAXSTRINGLEN 255/2
  22. #define MAXNUMARGS 64
  23. #define MAXDEFAULTLEN 512/2
  24.  
  25. STRPTR Template = "DosDev/M/A,ExecDev,UnitNr/N,FS/K,DosType/K";
  26.  
  27. enum WORD { ARG_DosDevA = 0, ARG_ExecDev, ARG_UnitNr, ARG_FS, ARG_DosType, ARG_ENDARG};
  28.  
  29. STRPTR CliHelp = "RDBMount V1.2  "__DATE__" © Sylvain ROUGIER.\n\
  30. Usage: RDBMount <DosDevName> [ExecDevName] [ExecUnitNr] [ FS FileSystemName] [DosType <DosType_in_hex>]\n\
  31. Default: ExecDevName = scsi.device ExecUnitNr = 0 or read Env \"RDBMount.DefOpts\"\n\
  32. Use to mount DOS Dev from the RigidDiskBlock information stored on (HD) drive\n";
  33.  
  34. const STRPTR VersTag = "$VER:RDBMount 1.1 (21.10.95) "__DATE__ " " __TIME__ " © Sylvain ROUGIER";
  35.  
  36. struct DosLibrary *DOSBase;
  37. struct Library *UtilityBase;
  38. struct Library *ExpansionBase;
  39. struct Library *HardBlocksBase;
  40.  
  41. char * CStrToBStr( char CStr[])
  42. {
  43.     ULONG l;
  44.     char *BStr;
  45.  
  46.     l = strlen( CStr);
  47.     if ( BStr = AllocMem( l + 1 + 1, MEMF_PUBLIC))
  48.         {
  49.             strcpy( &BStr[ 1], CStr);
  50.             BStr[ 0] = l;
  51.             return BStr;
  52.         }
  53.  
  54.     return NULL;
  55. }
  56.  
  57. char *B2CStr(UBYTE * BStr, char Buff[])
  58. {
  59.     UBYTE i;
  60.  
  61.     for (i = 0; i < *BStr; i++)
  62.     {
  63.         Buff[i] = (BStr + 1)[i];
  64.     }
  65.     Buff[i] = '\0';
  66.  
  67.     return Buff;
  68. }
  69.  
  70. BOOL IsMounted(char DosName[])
  71. {
  72.     struct DosList *DList;
  73.     BOOL Found = FALSE;
  74.  
  75.     DList = LockDosList(LDF_DEVICES | LDF_READ);
  76.     Found = (BOOL) FindDosEntry(DList, DosName, LDF_DEVICES);
  77.     UnLockDosList(LDF_DEVICES | LDF_READ);
  78.  
  79.     return Found;
  80. }
  81.  
  82. ULONG __asm Main(register __a0 APTR ArgV[], register __a1 struct WBStartup * WBenchMsg);
  83. ULONG __asm __Main(register __d2 ULONG CmdLen, register __a2 STRPTR CmdPtr)
  84. {
  85.     struct Process *pp;
  86.     ULONG RC = 1001;    /* assumle the worst */
  87.  
  88.     pp = (struct Process *)FindTask(0L);
  89.  
  90.     if (DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 34L))
  91.     {
  92.         if (DOSBase->dl_lib.lib_Version > 36)
  93.         {
  94.             APTR ArgV[MAXNUMARGS];
  95.             struct RDArgs *RA;
  96.             struct RDArgs *DefaultRDArgs;
  97.  
  98.             UtilityBase = DOSBase->dl_UtilityBase;
  99.             if (RA = AllocDosObject(DOS_RDARGS, NULL))
  100.             {
  101.                 memset(ArgV, 0, MAXNUMARGS * sizeof (APTR));
  102.                 RA->RDA_ExtHelp = CliHelp;
  103.                 /* first read default */
  104.                 /* getting the default string */
  105.                 if (DefaultRDArgs = AllocDosObject(DOS_RDARGS, NULL))
  106.                 {
  107.                     UBYTE Default[MAXDEFAULTLEN] = "DosDev Dummy ExecDev scsi.device UnitNr 0";
  108.  
  109.                     if ((DefaultRDArgs->RDA_Source.CS_Length = GetVar("RDBMount.DefOpts", Default, MAXDEFAULTLEN - 1, 0L)) > 0)
  110.                         ;
  111.                     else
  112.                         DefaultRDArgs->RDA_Source.CS_Length = strlen(Default);
  113.                     {
  114.                         /* let ReadArgs() allocate neccesary buffer sinc I use diferrent RDArgs for Default and CLI opts */
  115.  
  116.                         /* Ok I succefuly read a Default Option string now parse it */
  117.                         Default[DefaultRDArgs->RDA_Source.CS_Length++] = '\n';    /* this is need by ReadArgs() */
  118.                         Default[DefaultRDArgs->RDA_Source.CS_Length] = '\0';    /* this is need by ReadArgs() */
  119.                         DefaultRDArgs->RDA_Source.CS_Buffer = Default;
  120.                         DefaultRDArgs->RDA_Source.CS_CurChr = 0;
  121.                         DefaultRDArgs->RDA_Flags = RDAF_NOPROMPT;
  122.                         if (!ReadArgs(Template, (long *)ArgV, DefaultRDArgs))
  123.                         {
  124.                             PutStr("Error in Default:");
  125.                             PrintFault(IoErr(), NULL);
  126.                             memset(ArgV, 0, MAXNUMARGS * sizeof (APTR));
  127.                         }
  128.                         DefaultRDArgs->RDA_Source.CS_Buffer = NULL;    /* Now ReadArgs() from Command line */
  129.                         /* the ArgV is leaving unchanged: the second ReadArgs() take actual value as default */
  130.                     }
  131.                 }
  132.                 /* Let ReadArgs() allocate necessay buffer rather using stack space */
  133.                 if (ReadArgs(Template, (long *)ArgV, RA))
  134.                 {
  135.                     RC = Main(ArgV, NULL);
  136.                 }
  137.                 else
  138.                 {
  139.                     PrintFault(IoErr(), NULL);
  140.                     RC = 20;
  141.                 }
  142.                 FreeDosObject(DOS_RDARGS, RA);
  143.                 /* Free RDargs now I don't need the option value */
  144.                 if (DefaultRDArgs)
  145.                     FreeDosObject(DOS_RDARGS, DefaultRDArgs);
  146.             }
  147.         }
  148.         else
  149.         {
  150.             Write(pp->pr_COS, "You need KickStart 2.0+\n", 24L);
  151.             RC = 1000;
  152.         }
  153.         CloseLibrary((struct Library *)DOSBase);
  154.     }
  155.  
  156.     return RC;
  157. }
  158.  
  159. struct FileSysEntry *GetFileSys( ULONG DosType)
  160. {
  161.     struct FileSysResource *FileSysResource;
  162.     struct FileSysEntry *i;
  163.  
  164.     if ( FileSysResource = OpenResource( "FileSystem.resource"))
  165.     {
  166.         for ( i = ( struct FileSysEntry *)FileSysResource->fsr_FileSysEntries.lh_Head; i->fse_Node.ln_Succ; i = ( struct FileSysEntry *)i->fse_Node.ln_Succ)
  167.         {
  168.             if ( i->fse_DosType == DosType)
  169.                 return i;
  170.         }
  171.     }
  172.  
  173.     return NULL;
  174. }
  175.  
  176. ULONG __asm Main(register __a0 APTR ArgV[], register __a1 struct WBStartup * WBenchMsg)
  177. {
  178.     ULONG RC = 20;        /* default :Don't find desired Partition */
  179.  
  180.     ExpansionBase = OpenLibrary("expansion.library", 37L);
  181.  
  182.     if (HardBlocksBase = OpenLibrary(HardBlocksName, HardBlocksVersion))
  183.     {
  184.         struct RigidDiskBlock rdb;
  185.  
  186.         if (!(RC = LoadHardBlocks(&rdb, ArgV[ARG_ExecDev], *((ULONG *) ArgV[ARG_UnitNr]))))
  187.         {
  188.             #define MAXMOUNT 10
  189.             ULONG parmPkt[MAXMOUNT][21 + 10];    /* WARN: this is a lenthg which can change */
  190.             char DevNames[MAXMOUNT][20];    /* mem string don't be lost until the mount */
  191.             UBYTE MountCnt = 0;
  192.             UBYTE i, j;
  193.             char *Str;
  194.  
  195.             for (i = 0, Str = ((char **)ArgV[ARG_DosDevA])[0]; Str && (i < MAXMOUNT); i++, Str = ((char **)ArgV[ARG_DosDevA])[i])
  196.             {
  197.                 BOOL Found = FALSE;
  198.                 struct PartitionBlock *PB;
  199.                 char Buff[MAXSTRINGLEN];
  200.                 char DosDevName[MAXSTRINGLEN];
  201.  
  202.                 strcpy(DosDevName, Str);
  203.                 {
  204.                     UBYTE l;
  205.  
  206.                     if (DosDevName[l = (strlen(DosDevName) - 1)] == ':')
  207.                         DosDevName[l] = '\0';
  208.                 }
  209.                 if (!IsMounted(DosDevName))
  210.                 {
  211.                     for (PB = (struct PartitionBlock *)rdb.rdb_PartitionList; PB && !Found; PB = (struct PartitionBlock *)PB->pb_Next)
  212.                     {
  213.                         B2CStr(PB->pb_DriveName, Buff);
  214.                         //Printf( "Dos Name:\"%s\"\n", Buff);
  215.                         //Printf("pb:%lx, next:%lx\n", PB, PB->pb_Next);
  216.                         if (!Strnicmp(DosDevName, Buff, MAXSTRINGLEN))
  217.                         {
  218.                             Found = TRUE;
  219.                             strcpy(DevNames[MountCnt], Buff);
  220.                             parmPkt[MountCnt][0] = (ULONG) DevNames[MountCnt];
  221.                             parmPkt[MountCnt][1] = (ULONG) ArgV[ARG_ExecDev];
  222.                             parmPkt[MountCnt][2] = *((ULONG *) ArgV[ARG_UnitNr]);    /* unit number */
  223.                             parmPkt[MountCnt][3] = 0;    /* OpenDevice flags */
  224.                             if ( ArgV[ ARG_DosType])
  225.                             {
  226.                                 ULONG DosType= 0x00000000;
  227.  
  228.                                 if ( 8 == stch_l( ArgV[ ARG_DosType], (LONG *)&DosType))
  229.                                     PB->pb_Environment[ DE_DOSTYPE] = DosType;
  230.                                 else
  231.                                 {
  232.                                     Printf( "DosType:%s invalid (%l08x)\n", ArgV[ ARG_DosType], DosType);
  233.                                     break;
  234.                                 }
  235.                             }
  236.                             CopyMem(PB->pb_Environment, &parmPkt[MountCnt][4], sizeof (PB->pb_Environment));
  237.                             MountCnt++;
  238.                         }
  239.                     }
  240.                     if (!Found)
  241.                         Printf("\"%s:\" not found.\n", DosDevName);
  242.                 }
  243.                 else
  244.                 {
  245.                     Printf("\"%s:\" alredy mounted.\n", DosDevName);
  246.                 }
  247.             }
  248.             for (j = 0; j < MountCnt; j++)
  249.             {
  250.                 struct DeviceNode *DeviceNode;
  251.  
  252.                 if (DeviceNode = MakeDosNode(parmPkt[j]))
  253.                 {
  254.                     struct FileSysEntry *FileSysEntry;
  255.  
  256.                     if ( FileSysEntry = GetFileSys( parmPkt[ j][ 3 +17]))
  257.                     {
  258.                         if ( FileSysEntry->fse_PatchFlags & 0x00000001)
  259.                             DeviceNode->dn_Type = FileSysEntry->fse_Type;
  260.                         if ( FileSysEntry->fse_PatchFlags & 0x00000002)
  261.                             DeviceNode->dn_Task = ( struct MsgPort *)FileSysEntry->fse_Task;
  262.                         if ( FileSysEntry->fse_PatchFlags & 0x00000004)
  263.                             DeviceNode->dn_Lock = FileSysEntry->fse_Lock;
  264.                         if ( FileSysEntry->fse_PatchFlags & 0x00000008)
  265.                             DeviceNode->dn_Handler = FileSysEntry->fse_Handler;
  266.                         if ( FileSysEntry->fse_PatchFlags & 0x00000010)
  267.                             DeviceNode->dn_StackSize = FileSysEntry->fse_StackSize;
  268.                         if ( FileSysEntry->fse_PatchFlags & 0x00000020)
  269.                             DeviceNode->dn_Priority = FileSysEntry->fse_Priority;
  270.                         if ( FileSysEntry->fse_PatchFlags & 0x00000040)
  271.                             DeviceNode->dn_Startup = FileSysEntry->fse_Startup;
  272.                         if ( FileSysEntry->fse_PatchFlags & 0x00000080)
  273.                             DeviceNode->dn_SegList = FileSysEntry->fse_SegList;
  274.                         if ( FileSysEntry->fse_PatchFlags & 0x00000100)
  275.                             DeviceNode->dn_GlobalVec = FileSysEntry->fse_GlobalVec;
  276.                         /*{
  277.                             struct FileSysStartupMsg *fssm;
  278.                             struct DosEnvec *de;
  279.                             fssm = BADDR( DeviceNode->dn_Startup);
  280.                             de = BADDR( fssm->fssm_Environ);
  281.                             Printf( "toto");
  282.                         }*/
  283.                     }
  284.                     else
  285.                         Printf( "Can't find Segment for DosType:%l08x in FileSystem.resource\n", parmPkt[ j][ 3 +17]); 
  286.                     if ( ArgV[ ARG_FS])
  287.                     {
  288.                         DeviceNode->dn_Handler = MKBADDR( CStrToBStr( ArgV[ ARG_FS]));
  289.                         DeviceNode->dn_SegList = NULL;
  290.                         DeviceNode->dn_GlobalVec = -1;
  291.                     }
  292.                     
  293.                     if (!AddDosNode(-128, ADNF_STARTPROC, DeviceNode))
  294.                     {
  295.                         Printf("\"%s\" can't be Mounted\n", parmPkt[j][0]);
  296.                     }
  297.  
  298.                 }
  299.             }
  300.             FreeHardBlocks(&rdb);
  301.         }
  302.         else
  303.             Printf("Unable to Load RDB from \"%s\" %ld\n", ArgV[ARG_ExecDev], *((ULONG *) ArgV[ARG_UnitNr]));
  304.         CloseLibrary(HardBlocksBase);
  305.     }
  306.     else
  307.         Printf("Unable to open hardblocks.library V1+\n");
  308.  
  309.     CloseLibrary(ExpansionBase);
  310.  
  311.     return RC;
  312. }
  313.